home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 326-350 / disk_349 / med / source / med200src.zoo / med-buff.c < prev    next >
C/C++ Source or Header  |  1990-04-08  |  4KB  |  132 lines
  1. /* med-buff.c: MED buffer handling routines, by Teijo Kinnunen 1990 */
  2. #include <math.h> /* min(), abs() */
  3. #include "med.h"
  4.  
  5. static UBYTE *buffer, bufftracks, bufflines;
  6. static UBYTE markblock, marktrack, markline;
  7. extern UWORD soittolohko,currtrk,soittorivi,lohkoja;
  8. extern void __asm PaivitaNaytto(register __d0 BOOL);
  9. extern struct Lohko *lohko[];
  10.  
  11. void FreeBuffer()
  12. {
  13.     if(!buffer) return;
  14.     FreeMem((void *)buffer, bufftracks * bufflines * 3);
  15.     bufftracks = bufflines = 0;
  16.     buffer = NULL;
  17. }
  18.  
  19. BOOL AllocBuffer(UBYTE tracks,UBYTE lines) /* FALSE = ok, TRUE = error */
  20. {
  21.     FreeBuffer(); /* free the previous buffer */
  22.     if(!(buffer = AllocMem(tracks * lines * 3,MEMF_PUBLIC))) return(TRUE);
  23.     bufftracks = tracks;
  24.     bufflines = lines;
  25.     return(FALSE);
  26. }
  27.  
  28. void CutCopyPaste(UBYTE block,UBYTE startline,UBYTE lines,UBYTE starttrack,
  29.     UBYTE tracks,UBYTE op) /* op: 0 = copy, 1 = cut, 2 = paste, 3 = swap */
  30. {
  31.     UBYTE ntrks = lohko[block]->numtracks; /* tracks in the block */
  32.     UBYTE *p1 = &lohko[block]->music[startline * ntrks * 3 +
  33.                 starttrack * 3],*p2,linecnt,trkcnt,swb;
  34.     UBYTE *linep1,*linep2;
  35.     if(starttrack + tracks > ntrks) tracks = ntrks - starttrack;
  36.     if(startline + lines > 64) lines = 64 - startline;
  37.     if((op == 0 || op == 1) && AllocBuffer(tracks,lines)) { Ilmoita("No memory!!"); return; }
  38.     else if(op >= 2) {
  39.         if(lines > bufflines) lines = bufflines;
  40.         if(tracks > bufftracks) tracks = bufftracks;
  41.     }
  42.     if(!(p2 = buffer)) { Ilmoita("The buffer is empty."); return; }
  43.     for(linecnt = 0; linecnt < lines; linecnt++) {
  44.         linep1 = p1; linep2 = p2;
  45.         for(trkcnt = 0; trkcnt < tracks; trkcnt++) {
  46.             if(op == 0 || op == 1) { /* cut/copy */
  47.                 *p2=*p1; *(p2+1)=*(p1+1); *(p2+2)=*(p1+2);
  48.                 if(op == 1) *p1 = *(p1+1) = *(p1+2) = 0;
  49.             } else if(op == 2) { /* paste */
  50.                 *p1=*p2; *(p1+1)=*(p2+1); *(p1+2)=*(p2+2);
  51.             } else if(op == 3) { /* swap */
  52.                 swb = *p1; *p1 = *p2; *p2 = swb;
  53.                 swb=*(p1+1); *(p1+1)=*(p2+1); *(p2+1)=swb;
  54.                 swb=*(p1+2); *(p1+2)=*(p2+2); *(p2+2)=swb;
  55.             }
  56.             p1 += 3; p2 += 3; /* advance pointers one note */
  57.         }
  58.         p1 = linep1 + 3 * ntrks; /* advance blockptr one line */
  59.         p2 = linep2 + 3 * bufftracks; /* advance buffptr 1 line */
  60.     }
  61. }
  62.  
  63. void SetMark()
  64. {
  65.     markblock = (UBYTE)soittolohko;
  66.     markline = (UBYTE)soittorivi;
  67.     marktrack = (UBYTE)currtrk;
  68. }
  69.  
  70. void HandleMark(UBYTE code)
  71. {
  72.     UBYTE block = soittolohko,line = soittorivi,track = currtrk;
  73.     if(markblock != soittolohko && code != 0x34) {
  74.         Ilmoita("Only one block at a time!!"); return;
  75.     }
  76.     if(code == 0x34) CutCopyPaste((UBYTE)block,(UBYTE)line,
  77.         bufflines,(UBYTE)currtrk,bufftracks,2);
  78.     else    CutCopyPaste((UBYTE)block,(UBYTE)min(markline,line),
  79.         (UBYTE)(abs(markline-line)+1),(UBYTE)min(marktrack,track),
  80.         (UBYTE)(abs(marktrack - track) + 1),
  81.         (UBYTE)(code == 0x32 ? 1 : 0));
  82.     PaivitaNaytto(TRUE);
  83. }
  84.  
  85. void ExpandBlock(UWORD block)
  86. {
  87.     UBYTE linecnt,prevblk = (UBYTE)lohkoja,tracks;
  88.     if(lohkoja >= 100) {
  89.         Ilmoita("Too many blocks!!"); return;
  90.     }
  91.     tracks = lohko[block]->numtracks;
  92.     NewBlockHere(block+1,tracks);
  93.     if(lohkoja != prevblk+1 || lohko[block+1]->numtracks != tracks) {
  94.         Ilmoita("Out of memory!!"); return; }
  95.     for(linecnt = 0; linecnt < 64; linecnt++) {
  96.         if(linecnt & 0x1) /* clear odd-numbered lines */
  97.             memset(&lohko[block+1]->music[linecnt * 3 * tracks],
  98.                 0,3 * tracks);
  99.         else    memcpy(&lohko[block+1]->music[linecnt * 3 * tracks],
  100.                 &lohko[block]->music[(32 + linecnt / 2) *
  101.                 3 * tracks], 3 * tracks);
  102.     }
  103.     for(linecnt = 63; linecnt; linecnt--) {
  104.         if(linecnt & 0x1)
  105.             memset(&lohko[block]->music[linecnt * 3 * tracks],
  106.                 0,3 * tracks);
  107.         else    memcpy(&lohko[block]->music[linecnt * 3 * tracks],
  108.             &lohko[block]->music[(linecnt / 2) * 3 * tracks],
  109.             3 * tracks);
  110.     }
  111.     PaivitaNaytto(TRUE);
  112.     TulostaLohkoJaSoitin();
  113. }
  114.  
  115. void ShrinkBlock(UWORD block)
  116. {
  117.     UBYTE linecnt,tracks = lohko[block]->numtracks;
  118.     if(!lohko[block+1]) { Ilmoita("There's no second block."); return; }
  119.     if(tracks != lohko[block+1]->numtracks) {
  120.         Ilmoita("Not the same number of tracks!!"); return; }
  121.     for(linecnt = 0; linecnt < 64; linecnt++) {
  122.         if(linecnt < 32)    memcpy(&lohko[block]->music[
  123.             linecnt * 3 * tracks],&lohko[block]->music[
  124.             linecnt * 6 * tracks],3 * tracks);
  125.         else    memcpy(&lohko[block]->music[linecnt * 3 * tracks],
  126.                 &lohko[block+1]->music[(linecnt - 32) *
  127.                 6 * tracks], 3 * tracks);
  128.     }
  129.     PaivitaNaytto(TRUE);
  130.     TulostaLohkoJaSoitin();
  131. }
  132.